ETO Development Tools 2/ETO Development Tools 2.iso/Tools - Objects/MacApp/MacApp CD Release/MacApp 2.0.1 (Many Libraries)/Libraries/UMenuSetup.inc1.p

Text File | 1990-10-25 | 20.6 KB | 809 lines | [TEXT/MPS ]

{$P}
{[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n-]}
{ UMenuSetup.inc1.p }
{ Copyright © 1984-1990 by Apple Computer Inc. All rights reserved. }

{--------------------------------------------------------------------------------------------------}

CONST
    _MAInvalMenuBar = $A81D;            { Trap number for invalidate menu bar on 7.0 systems }

TYPE
    { the following must match the declaration in the PostRez tool }
    MenuCmdRecord        = RECORD
        theCmdNumber:        INTEGER;
        theMenuNumber:        INTEGER;
        theItemNumber:        INTEGER;
        END;

    CmdTable            = ARRAY [1..4000] OF MenuCmdRecord; { Actually variable length }
    CmdTablePtr         = ^CmdTable;
    CmdTableHandle        = ^CmdTablePtr;

    MAMenuCRsrcPtr        = ^MAMenuCRsrc;                    {!!! After MPW 3.1 use the PInterfaces vers }
    MAMenuCRsrcHandle    = ^MAMenuCRsrcPtr;
    MAMenuCRsrc         = RECORD
        numEntries:         INTEGER;                    {number of entries}
        data:                ARRAY [1..1] OF MCEntry;
        END;

PROCEDURE MAInvalMenuBar;
INLINE _MAInvalMenuBar;
{ The trap name will be InvalMenuBar. The trap number will be $A81D. It will
test as unimplemented on old systems. (There will also be a Gestalt selector.) }

{--------------------------------------------------------------------------------------------------}

VAR
    pHNullMenuProc:     Handle;                         { Handle to null menu proc }

    pCmdTable:            CmdTableHandle;                 { maps CmdNumber <--> (menu,item) }
    pSizeCmdTable:        INTEGER;                        { number of records in pCmdTable }

{--------------------------------------------------------------------------------------------------}

PROCEDURE NullMenuProc(message: INTEGER;
                       aMenuHandle: MenuHandle;
                       VAR menuRect: Rect;
                       hitPt: Point;
                       VAR whichItem: INTEGER);
    FORWARD;

{--------------------------------------------------------------------------------------------------}
{$IFC qDebug}
{$S MADebug}

FUNCTION TraceMenuName(aCmd: CmdNumber): CHAR;
{ For debugging purposes only--used to dump the name and number of a command }

    VAR
        cmdName:            Str255;

    BEGIN
    CmdToName(aCmd, cmdName);
    Write(aCmd: 1, ' [', cmdName, '],');
    TraceMenuName := ' ';
    END;
{$ENDC}

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE InvalidateMenus;

    BEGIN
    gMenusAreSetup := FALSE;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE ValidateMenus;

    BEGIN
    gMenusAreSetup := TRUE;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION MenusHavePendingUpdate: Boolean;

    BEGIN
    MenusHavePendingUpdate := NOT gMenusAreSetup;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE InvalidateMenuBar;

    BEGIN
    InvalidateMenus;                                    { if the menubar is invalidated then the
                                                         menu items must be also }


    { On systems that have invalidate menu bar use that functionality instead of setting the global.
    The system will redraw the menu bar at the next convenient time. }
    IF (gConfiguration.systemVersion >= $0600) & TrapExists(_MAInvalMenuBar) THEN
        BEGIN
        MAInvalMenuBar;
        gRedrawMenuBar := FALSE;
        END
    ELSE
        gRedrawMenuBar := TRUE;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE ValidateMenuBar;

    BEGIN
    gRedrawMenuBar := FALSE;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION MenuBarHasPendingUpdate;

    BEGIN
    MenuBarHasPendingUpdate := gRedrawMenuBar;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION CmdEnabled(cmd: CmdNumber): Boolean;

    VAR
        menuNo, itemNo:     INTEGER;
        theMenu:            MenuHandle;

    BEGIN
    theMenu := CmdToComponents(cmd, menuNo, itemNo);

    IF theMenu <> NIL THEN
        IF (itemNo > 0) & (itemNo < 32) THEN
            CmdEnabled := BTst(theMenu^^.enableFlags, itemNo)
        ELSE
            CmdEnabled := TRUE
    ELSE
        CmdEnabled := FALSE;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION CmdFromMenuItem(menu, item: INTEGER): CmdNumber;
 { Given a menuID/item # return the appropriate command number. IF there
  is no such command number, return -BOR(BSL(menu, 8), item).  If the
  item number is <0 then assume that it is a negative command number. }

    VAR
        i:                    INTEGER;
        p:                    CmdTablePtr;

    BEGIN
    IF item < 0 THEN
        CmdFromMenuItem := - item
    ELSE
        BEGIN
        IF item > 0 THEN
            BEGIN
            p := pCmdTable^;

            FOR i := 1 TO pSizeCmdTable DO
                WITH p^[i] DO
                    IF (menu = theMenuNumber) & (item = theItemNumber) THEN
                        BEGIN
                        CmdFromMenuItem := theCmdNumber;
                        Exit(CmdFromMenuItem);
                        END;
            END;
        {$IFC qDebug}
        IF (menu > 127) | (item > 255) THEN
            BEGIN
            Writeln('menu = ', menu: 1, '  item = ', item: 1);
            Writeln('Menu/item number is too big for a negative command number!');
            ProgramBreak('Try using a negative item number instead.');
            END;
        {$ENDC}

        CmdFromMenuItem := - BOR(BSL(menu, 8), item);
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE CmdToMenuItem(aCmd: CmdNumber;
                        VAR menu, item: INTEGER);

    VAR
        p:                    CmdTablePtr;
        low:                INTEGER;
        high:                INTEGER;
        test:                INTEGER;

    BEGIN
    IF aCmd < 0 THEN
        BEGIN
        menu := BSR( - aCmd, 8);
        item := BAND( - aCmd, 255);
        END
    ELSE
        BEGIN
        { Use a binary search to find the command number in the table }
        low := 1;
        high := pSizeCmdTable;

        p := pCmdTable^;
        WHILE low <= high DO
            BEGIN
            test := BSR(low + high, 1);                 { (low + high) DIV 2 }
            WITH p^[test] DO
                IF aCmd = theCmdNumber THEN
                    BEGIN
                    menu := theMenuNumber;
                    item := theItemNumber;
                    Exit(CmdToMenuItem);
                    END
                ELSE IF aCmd < theCmdNumber THEN
                    high := test - 1
                ELSE
                    low := test + 1;
            END;

        { not found }
        menu := 0;
        item := 0;
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE CmdToName(aCmd: CmdNumber;
                    VAR menuText: Str255);

    VAR
        aMenu:                INTEGER;
        anItem:             INTEGER;
        mHandle:            MenuHandle;

    BEGIN
    menuText := '';

    mHandle := CmdToComponents(aCmd, aMenu, anItem);
    IF mHandle <> NIL THEN
        GetItem(mHandle, anItem, menuText);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION CmdToComponents(cmd: CmdNumber; VAR menuNo, itemNo: integer): MenuHandle;

    VAR
        theMenu: MenuHandle;

    BEGIN
    CmdToMenuItem(cmd, menuNo, itemNo);
    IF menuNo <> 0 THEN { was found }
        CmdToComponents := MAGetMenu(menuNo)
    ELSE
        CmdToComponents := NIL;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE EachMenuDo(PROCEDURE DoToMenu(aMenuHandle: MenuHandle; isHierarchical: Boolean);
                     includeHierarchical: Boolean);
 { Calls DoToMenu for each menu in the menu bar, including the
  hierarchical and popup menus if includeHierarchical is TRUE. }
    CONST
        kHierArchical        = TRUE;
        kNotHierArchical    = NOT kHierArchical;

    TYPE
        { See IM V, Menu Manager, 'Menu Mgr Data Structures' pp.228-30 }
        MAMenuRec            = RECORD
            menuOH:             MenuHandle;             { menu's data }
            menuLeft:            INTEGER;                { pixels }
            END;
        MAMenuRecPtr        = ^MAMenuRec;

        MAHMenuRec            = RECORD
            menuOH:             MenuHandle;             { hierarchical menu's data }
            reserved:            INTEGER;                { reserved for future use }
            END;
        MAHMenuRecPtr        = ^MAHMenuRec;

        MADynamicMenuList    = RECORD
            lastMenu:            INTEGER;                { Offset }
            lastRight:            INTEGER;                { Pixels }
            mbResID:            INTEGER;
            menu:                ARRAY [0..0] OF MAMenuRec; { Variable number of menus }

            lastHMenu:            INTEGER;                { Offset }
            menuTitleSave:        PixMapHandle;            { handle to bits behind inverted menu title
                                                         }
            hMenu:                 ARRAY [0..0] OF MAHMenuRec; { Variable number of menus }
            END;
        MADynamicMenuListPtr = ^MADynamicMenuList;
        MADynamicMenuListHandle = ^MADynamicMenuListPtr;

    VAR
        wasLocked:            BOOLEAN;

    PROCEDURE WalkAMenuRecArray(aMenuRecPtr: MAMenuRecPtr;
                                lastMenuOffset: INTEGER;
                                isHierarchical: Boolean);
    { NOTE: Assumes a MAMenuRec and a MAHMenuRec are the same size }

        VAR
            aMenuHandle:        MenuHandle;
            endAddress:            MAMenuRecPtr;

        BEGIN
        endAddress := MAMenuRecPtr(ORD(aMenuRecPtr) + lastMenuOffset);
        While (ORD(aMenuRecPtr) < ORD(endAddress)) DO
            BEGIN
            aMenuHandle := aMenuRecPtr^.menuOH;

            IF qDebug & NOT IsHandle(aMenuHandle) THEN
                BEGIN
                IF VerboseIsHandle(aMenuHandle) THEN;
                WrLblPtr('Bad menuHandle was', aMenuHandle);
                ProgramBreak('I guess it''s not a MenuHandle, huh?');
                END
            ELSE
                FailNIL(aMenuHandle);

            IF (qDebug | qInspector) & (aMenuHandle^^.menuID = mDebug) THEN {??? why? }
                BEGIN
                aMenuHandle^^.menuID := 0;                { store info about debug menu in index 0 }
                DoToMenu(aMenuHandle, isHierarchical);
                aMenuHandle^^.menuID := mDebug;
                END
            ELSE
            DoToMenu(aMenuHandle, isHierarchical);

            aMenuRecPtr := MAMenuRecPtr(ORD(aMenuRecPtr) + SizeOf(MAMenuRec));
            END;
        END;

    BEGIN
    { Do regular menus }

    wasLocked :=  IsHandleLocked(GetMenuList);
    LockHandleHigh(GetMenuList);

    WITH MADynamicMenuListHandle(GetMenuList)^^ DO
        WalkAMenuRecArray(MAMenuRecPtr(@menu), lastMenu, kNotHierArchical);

    { Now do hierarchial menus }
    IF (qNeedsHierarchicalMenus | gConfiguration.hasHierarchicalMenus) & includeHierarchical THEN
        WITH MADynamicMenuListHandle(GetMenuList)^^ DO
            WalkAMenuRecArray(MAMenuRecPtr(ORD(@menu) + lastMenu + SizeOf(INTEGER) +
                                           SizeOf(PixMapHandle)), IntegerPtr(ORD(@menu) +
                              lastMenu)^, kHierArchical);
    IF NOT wasLocked THEN
        HUnlock(GetMenuList);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE Enable(aCmd: CmdNumber;
                 canDo: Boolean);

    VAR
        menu, item:         INTEGER;
        aMenuHandle:        MenuHandle;

    BEGIN
    {$IFC qDebug}
    IF gTraceSetupMenus THEN
        Writeln('..... Enable(', TraceMenuName(aCmd), gBoolString[canDo], ')');
    {$ENDC}
    aMenuHandle := CmdToComponents(aCmd, menu, item);
    IF aMenuHandle <> NIL THEN
        IF canDo THEN
            EnableItem(aMenuHandle, item)
        ELSE
            DisableItem(aMenuHandle, item);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE EnableCheck(aCmd: CmdNumber;
                      canDo, checkIt: Boolean);

    VAR
        menu, item:         INTEGER;
        aMenuHandle:        MenuHandle;

    BEGIN
    {$IFC qDebug}
    IF gTraceSetupMenus THEN
        Writeln('..... EnableCheck(', TraceMenuName(aCmd), gBoolString[canDo], ', ',
                gBoolString[checkIt], ')');
    {$ENDC}
    aMenuHandle := CmdToComponents(aCmd, menu, item);
    IF aMenuHandle <> NIL THEN
        BEGIN
        IF canDo THEN
            EnableItem(aMenuHandle, item)
        ELSE
            DisableItem(aMenuHandle, item);
        CheckItem(aMenuHandle, item, checkIt);
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION GetResMenu(menuResID: INTEGER): MenuHandle;
{ Allow us to get a menu when it's not available via GetMHandle.
!!! Really should perform the other functions of GetMenu (load menuproc, color table, etc.}

    PROCEDURE DoGetResMenu;

        BEGIN
        GetResMenu := MenuHandle(GetResource('MENU', menuResID));
        END;

    BEGIN
    WithApplicationResFileDo(DoGetResMenu);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAInit}

PROCEDURE InitUMenuSetup;

    TYPE
        JmpRecPtr            = ^JmpRec;
        JmpRec                = RECORD
            opcode:             INTEGER;
            target:             Ptr;
            END;

        {$IFC qDebug}

    VAR
        i:                    INTEGER;
        previousCmdNumber:    INTEGER;
        {$ENDC}

    BEGIN
    { read in the command table }
    pCmdTable := CmdTableHandle(GetResource(kMNTBbyCmdNumber, kIDMNTBbyCmdNumber));
    FailNilResource(pCmdTable);
    pSizeCmdTable := GetHandleSize(Handle(pCmdTable)) DIV SIZEOF(MenuCmdRecord);

    {$IFC qDebug}
    previousCmdNumber := MAXINT;
    FOR i := 1 TO pSizeCmdTable DO
        BEGIN
        IF pCmdTable^^[i].theCmdNumber = previousCmdNumber THEN
            ProgramBreak(ConcatNumber('Duplicate command number not allowed: ', previousCmdNumber));
        previousCmdNumber := pCmdTable^^[i].theCmdNumber;
        END;
    {$ENDC}

    pHNullMenuProc := NewPermHandle(6);
    FailNIL(pHNullMenuProc);
    WITH JmpRecPtr(pHNullMenuProc^)^ DO
        BEGIN
        opcode := $4EF9;                                { JMP }
        target := @NullMenuProc;
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

FUNCTION MAGetMenu(menuNo: INTEGER): MenuHandle;

    VAR
        theMenu: MenuHandle;

    BEGIN
    theMenu := GetMHandle(menuNo); { do this first ... the menu is likely to be in the menubar and
                                    more likely of success, hence, faster }
    IF theMenu = NIL THEN
        theMenu := GetResMenu(menuNo);

    MAGetMenu := theMenu;
    END;


{--------------------------------------------------------------------------------------------------}
{$S MAInit}

FUNCTION MAGetNewMBar(menuRsrcID: INTEGER): Handle;

    VAR
        theColorTab:        MCTableHandle;
        theColorRsrc:        MAMenuCRsrcHandle;
        itsRsrcHandle:        Handle;
        savedState:            SignedByte;

    BEGIN
    IF qNeedsColorQD | gConfiguration.hasColorQD THEN
        theColorTab := GetMCInfo;

    { make the 'MBAR' resource non-purgeable, so the Toolbox doesn't die }
    itsRsrcHandle := GetResource('MBAR', menuRsrcID);
    IF itsRsrcHandle <> NIL THEN
        BEGIN
        savedState := HGetState(itsRsrcHandle);
        HNoPurge(itsRsrcHandle);
        END;

    MAGetNewMBar := GetNewMBar(menuRsrcID);

    { restore the 'MBAR' resource }
    IF itsRsrcHandle <> NIL THEN
        HSetState(itsRsrcHandle, savedState);

    IF (theColorTab <> NIL) THEN
        IF qNeedsColorQD | gConfiguration.hasColorQD THEN
            BEGIN
            HLock(Handle(theColorTab));
            SetMCEntries(GetHandleSize(Handle(theColorTab)) DIV SIZEOF(MCEntry), theColorTab^);
            HUnlock(Handle(theColorTab));
            DispMCInfo(theColorTab);
            END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE MAInsertMenu(theMenu: MenuHandle;
                       beforeID: INTEGER);

    VAR
        theColorRsrc:        MAMenuCRsrcHandle;

    BEGIN
    InsertMenu(theMenu, beforeID);
 { Since only GetMenu automatically loads the appropriate color information,
  and (sigh) since we can only call GetMenu once, and if you call DeleteMenu
  all the good color stuff goes away (double sigh) we'll have to help out
  the Menu Manager by doing its job for it }
    IF qNeedsColorQD | gConfiguration.hasColorQD THEN
        BEGIN
        theColorRsrc := MAMenuCRsrcHandle(GetResource('mctb', theMenu^^.menuID));
        IF theColorRsrc <> NIL THEN
            BEGIN
            HLock(Handle(theColorRsrc));
            WITH theColorRsrc^^ DO
                SetMCEntries(numEntries, @data[1]);
            HUnlock(Handle(theColorRsrc));
            ReleaseResource(Handle(theColorRsrc));
            END;
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE NeedCalcMenuSize(aMenuHandle: MenuHandle);

    BEGIN
    WITH aMenuHandle^^ DO
        IF menuProc = pHNullMenuProc THEN
            menuWidth := 0;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}
 { a null menuProc that is used to inhibit re-calculating the menu's size after each
  call to EnableItem, CheckItem, etc. }

PROCEDURE NullMenuProc(message: INTEGER;
                       aMenuHandle: MenuHandle;
                       VAR menuRect: Rect;
                       hitPt: Point;
                       VAR whichItem: INTEGER);

    BEGIN
    aMenuHandle^^.menuWidth := 0;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE PerformMenuSetup(PROCEDURE TheMenuSetterUpper);

    CONST
        kDoHierArchical        = TRUE;
        kDontDoHierArchical    = NOT kDoHierArchical;

        { If hierarchical the range of IDs for applications is restricted
        See IM V-236. }
        kHierarchicalMin    = 0;
        kHierarchicalMax    = 235;


    TYPE
        EnableArray         = PACKED ARRAY [0..mLastMenu] OF Boolean; { Saved enable flags }
        SavePrArray         = ARRAY [0..mLastMenu] OF Handle; { Saved menu procs }

    VAR
        aMenuHandle:        MenuHandle;
        wasEnabled:         EnableArray;
        savedProcs:         SavePrArray;

FUNCTION IsManagedMenu(aMenuHandle: MenuHandle; isHierarchical: Boolean): BOOLEAN;

    BEGIN
    WITH aMenuHandle^^ DO
    IsManagedMenu := (((menuID >= mFirstMenu) & (menuID <= mLastMenu)) { Range of managed menus }
           & (menuID <> mApple)                                        { _NEVER_ managed! }
           & (NOT isHierarchical                                    { No further restrictions, unless… }
           | (isHierarchical & (menuID >= kHierarchicalMin) & (menuID <= kHierarchicalMax)))) { must
               be in valid range }
    END;

PROCEDURE StartMenuSetup(aMenuHandle: MenuHandle; isHierarchical: Boolean);

    VAR
        item: INTEGER;
        theCmd: CHAR;

    BEGIN
    IF IsManagedMenu(aMenuHandle, isHierarchical) THEN
        WITH aMenuHandle^^ DO
            BEGIN
                { Remember the menu itself was enabled, and disable the menu
                 and all of its items. }
            wasEnabled[menuID] := Odd(enableFlags);
            enableFlags := 0;

                { Save the menu's menuproc and set it to the NullMenuProc, so that
                 CalcMenuSize is disabled (will do ÇalcMenuSize at end of setup). }
            savedProcs[menuID] := menuProc; { See comment below }
            menuProc := pHNullMenuProc;

            { Uncheck all items. }
            FOR item := 1 TO CountMItems(aMenuHandle) DO
              { Make sure we don't check items with sub-menus }
                IF qNeedsHierarchicalMenus | gConfiguration.hasHierarchicalMenus THEN
                    BEGIN
                    GetItemCmd(aMenuHandle, item, theCmd);
                    IF ORD(theCmd) <> hMenuCmd THEN
                        CheckItem(aMenuHandle, item, FALSE);
                    END
                ELSE
                    CheckItem(aMenuHandle, item, FALSE);
            END;
    END;

PROCEDURE EndMenuSetup(aMenuHandle: MenuHandle; isHierarchical: Boolean);

    VAR
        newFlags: LongInt;
        menuID: INTEGER;

    BEGIN
    IF IsManagedMenu(aMenuHandle, isHierarchical) THEN
        WITH aMenuHandle^^ DO
            BEGIN

            newFlags := enableFlags;
            { If any items are enabled, enable the menu }
            IF newFlags <> 0 THEN
                BEGIN
                newFlags := BOR(1, newFlags);
                enableFlags := newFlags;
                END;

            { If the menu's enabled state changed, we have to draw the menu bar. }
            IF Odd(newFlags) <> wasEnabled[menuID] THEN
                InvalidateMenuBar;

            { Restore the menuproc. }
            menuProc := savedProcs[menuID];

                { menuWidth set to 0 by routines that require CalcMenuSize, by
                 calling NeedCalcMenu. }
            IF menuWidth = 0 THEN
                CalcMenuSize(aMenuHandle);
            END;
    END;

    BEGIN
    EachMenuDo(StartMenuSetup, kDoHierArchical);
    TheMenuSetterUpper;
    EachMenuDo(EndMenuSetup, kDoHierArchical);

    IF MenuBarHasPendingUpdate THEN
        BEGIN
        DrawMenuBar;
        ValidateMenuBar;
        END;

    ValidateMenus;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE SetCmdIcon(aCmd: CmdNumber;
                     menuIcon: Byte);

    VAR
        menu, item:         INTEGER;
        aMenuHandle:        MenuHandle;

    BEGIN
    {$IFC qDebug}
    IF gTraceSetupMenus THEN
        Writeln('..... SetCmdIcon(', TraceMenuName(aCmd), menuIcon: 1, ')');
    {$ENDC}
    aMenuHandle := CmdToComponents(aCmd, menu, item);
    IF aMenuHandle <> NIL THEN
        SetItemIcon(aMenuHandle, item, menuIcon);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE SetCmdName(aCmd: CmdNumber;
                     menuText: Str255);

    VAR
        menu, item:         INTEGER;
        aMenuHandle:        MenuHandle;

    BEGIN
    {$IFC qDebug}
    IF gTraceSetupMenus THEN
        Writeln('..... SetCmdName(', TraceMenuName(aCmd), '“', menuText, '”)');
    {$ENDC}
    aMenuHandle := CmdToComponents(aCmd, menu, item);
    IF aMenuHandle <> NIL THEN
        SetItem(aMenuHandle, item, menuText);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE SetIndCmdName(aCmd: CmdNumber;
                        rsrcID, strIndex: INTEGER);

    VAR
        s:                    Str255;

    BEGIN
    GetIndString(s, rsrcID, strIndex);
    SetCmdName(aCmd, s);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE SetMenuState(aCmd: CmdNumber;
                       rsrcID, falseBuzzItem, trueBuzzItem: INTEGER;
                       stateVariable: Boolean);

    VAR
        buzzItem:            INTEGER;

    BEGIN
    IF stateVariable THEN
        buzzItem := trueBuzzItem
    ELSE
        buzzItem := falseBuzzItem;

    SetIndCmdName(aCmd, rsrcID, buzzItem);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAMenuRes}

PROCEDURE SetStyle(aCmd: CmdNumber;
                   aStyle: Style);

    VAR
        menu, item:         INTEGER;
        aMenuHandle:        MenuHandle;

    BEGIN
    {$IFC qDebug}
    IF gTraceSetupMenus THEN
        Writeln('..... SetStyle(', TraceMenuName(aCmd), Ptr(@aStyle)^: 1, ')');
    {$ENDC}
    aMenuHandle := CmdToComponents(aCmd, menu, item);
    IF aMenuHandle <> NIL THEN
        SetItemStyle(aMenuHandle, item, aStyle);
    END;